home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / echogs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-13  |  7.5 KB  |  295 lines
  1. /* Copyright (C) 1992, 1995, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* echogs.c */
  20. /* 'echo'-like utility */
  21. #include <stdio.h>
  22. /* Some brain-damaged environments (e.g. Sun) don't include */
  23. /* prototypes for fputc/fputs in stdio.h! */
  24. extern int fputc(), fputs();
  25. /* Some systems have time_t in sys/types.h rather than time.h. */
  26. #include <sys/types.h>
  27. #include <ctype.h>
  28. #include <string.h>
  29. #include <time.h>        /* for ctime */
  30. /* The VMS environment uses different values for success/failure exits: */
  31. #ifdef VMS
  32. #include <stdlib.h>
  33. #  define exit_OK 1
  34. #  define exit_FAILED 18
  35. #else
  36. #  define exit_OK 0
  37. #  define exit_FAILED 1
  38. #endif
  39.  
  40. /*
  41.  * This program exists solely to get around omissions, problems, and
  42.  * incompatibilities in various shells and utility environments.
  43.  * Don't count on it staying the same from one release to another!
  44.  */
  45.  
  46. /*
  47.  * Usage:
  48.     echogs [-e .extn] [-(w|a)[b][-] file] [-h] [-n]
  49.       (-d|-D | -f|-F | -x hexstring | -(l|q|Q) string | -(l|q|Q)string |
  50.        -s | -u string | -i | -r file | -R file | -X)*
  51.       [-] string*
  52.  * Echoes string(s), or the binary equivalent of hexstring(s).
  53.  * If -w, writes to file; if -a, appends to file; if neither,
  54.  *   writes to stdout.  -wb and -ab open the file in binary mode.
  55.  *   -w and -a search forward for the next argument that is not a switch.
  56.  *   An appended - means the same as - alone, taking effect after the file
  57.  *   argument.
  58.  * -e specifies an extension to be added to the file name.
  59.  * If -h, write the output in hex instead of literally.
  60.  * If -n, does not append a newline to the output.
  61.  * -d or -D means insert the date and time.
  62.  * -f or -F means insert the file name passed as the argument of -w or -a.
  63.  * -q means write the next string literally.
  64.  * -l or -Q means the same as -q followed by -s.
  65.  * -s means write a space.
  66.  * -u means convert the next string to upper case.
  67.  * -i means read from stdin, treating each line as an argument.
  68.  * -r means read from a named file in the same way.
  69.  * -R means copy a named file with no interpretation
  70.  *   (but convert to hex if -h is in effect).
  71.  * -X means treat any following literals as hex rather than string data.
  72.  * - alone means treat the rest of the line as literal data,
  73.  *   even if the first string begins with a -.
  74.  * -+<letter> is equivalent to -<Letter>, i.e., it upper-cases the letter.
  75.  * Inserts spaces automatically between the trailing strings,
  76.  * but nowhere else; in particular,
  77.     echogs -q a b
  78.  * writes 'ab', in contrast to
  79.     echogs -q a -s b
  80.  * which writes 'a b'.
  81.  */
  82.  
  83. static int hputc(), hputs();
  84.  
  85. main(int argc, char *argv[])
  86. {    FILE *out = stdout;
  87.     FILE *in;
  88.     char *extn = "";
  89.     char fmode[4];
  90. #define FNSIZE 100
  91.     char *fnparam;
  92.     char fname[FNSIZE];
  93.     int newline = 1;
  94.     int interact = 0;
  95.     int (*eputc)() = fputc, (*eputs)() = fputs;
  96. #define LINESIZE 1000
  97.     char line[LINESIZE];
  98.     char sw = 0, sp = 0, hexx = 0;
  99.     char **argp = argv + 1;
  100.     int nargs = argc - 1;
  101.     if ( nargs > 0 && !strcmp(*argp, "-e") )
  102.     {    if ( nargs < 2 ) return 1;
  103.         extn = argp[1];
  104.         argp += 2, nargs -= 2;
  105.     }
  106.     if ( nargs > 0 && (*argp)[0] == '-' &&
  107.           ((*argp)[1] == 'w' || (*argp)[1] == 'a')
  108.        )
  109.     {    size_t len = strlen(*argp);
  110.         int i;
  111.         if ( len > 4 ) return 1;
  112.         for ( i = 1; i < nargs; i++ )
  113.           if ( argp[i][0] != '-' ) break;
  114.         if ( i == nargs ) return 1;
  115.         fnparam = argp[i];
  116.         strcpy(fmode, *argp + 1);
  117.         strcpy(fname, fnparam);
  118.         strcat(fname, extn);
  119.         if ( fmode[len-2] == '-' )
  120.           {    fmode[len-2] = 0;
  121.             argp[i] = "-";
  122.             argp++, nargs--;
  123.           }
  124.         else
  125.           {    for ( ; i > 1; i-- )
  126.               argp[i] = argp[i-1];
  127.             argp += 2, nargs -= 2;
  128.           }
  129.     }
  130.     else
  131.         strcpy(fname, "");
  132.     if ( nargs > 0 && !strcmp(*argp, "-h") )
  133.     {    eputc = hputc, eputs = hputs;
  134.         argp++, nargs--;
  135.     }
  136.     if ( nargs > 0 && !strcmp(*argp, "-n") )
  137.     {    newline = 0;
  138.         argp++, nargs--;
  139.     }
  140.     if ( strlen(fname) != 0 )
  141.     {    out = fopen(fname, fmode);
  142.         if ( out == 0 ) return 1;
  143.     }
  144.     while ( 1 )
  145.     {    char *arg;
  146.         if ( interact )
  147.         {    if ( fgets(line, LINESIZE, in) == NULL )
  148.             {    interact = 0;
  149.                 if ( in != stdin ) fclose(in);
  150.                 continue;
  151.             }
  152.             /* Remove the terminating \n. */
  153.             line[strlen(line) - 1] = 0;
  154.             arg = line;
  155.         }
  156.         else
  157.         {    if ( nargs == 0 ) break;
  158.             arg = *argp;
  159.             argp++, nargs--;
  160.         }
  161.         if ( sw == 0 && arg[0] == '-' )
  162.         {    char chr = arg[1];
  163.  
  164.             sp = 0;
  165. swc:            switch ( chr )
  166.             {
  167.             case '+':        /* upper-case command */
  168.                 ++arg;
  169.                 chr = toupper(arg[1]);
  170.                 goto swc;
  171.             case 'l':        /* literal string, then -s */
  172.                 chr = 'Q';
  173.                 /* falls through */
  174.             case 'q':        /* literal string */
  175.             case 'Q':        /* literal string, then -s */
  176.                 if ( arg[2] != 0 )
  177.                   {    (*eputs)(arg + 2, out);
  178.                     if ( chr == 'Q' )
  179.                       (*eputc)(' ', out);
  180.                     break;
  181.                   }
  182.                 /* falls through */
  183.             case 'r':        /* read from a file */
  184.             case 'R':
  185.             case 'u':        /* upper-case string */
  186.             case 'x':        /* hex string */
  187.                 sw = chr;
  188.                 break;
  189.             case 's':        /* write a space */
  190.                 (*eputc)(' ', out);
  191.                 break;
  192.             case 'i':        /* read interactively */
  193.                 interact = 1;
  194.                 in = stdin;
  195.                 break;
  196.             case 'd':        /* insert date/time */
  197.             case 'D':
  198.             {    time_t t;
  199.                 char str[26];
  200.                 time(&t);
  201.                 strcpy(str, ctime(&t));
  202.                 str[24] = 0;    /* remove \n */
  203.                 (*eputs)(str, out);
  204.             }    break;
  205.             case 'f':        /* insert file name */
  206.             case 'F':
  207.                 (*eputs)(fnparam, out);
  208.                 break;
  209.             case 'X':        /* treat literals as hex */
  210.                 hexx = 1;
  211.                 break;
  212.             case 0:            /* just '-' */
  213.                 sw = '-';
  214.                 break;
  215.             }
  216.         }
  217.         else
  218.           switch ( sw )
  219.         {
  220.         case 0:
  221.         case '-':
  222.             if ( hexx ) goto xx;
  223.             if ( sp ) (*eputc)(' ', out);
  224.             (*eputs)(arg, out);
  225.             sp = 1;
  226.             break;
  227.         case 'q':
  228.             sw = 0;
  229.             (*eputs)(arg, out);
  230.             break;
  231.         case 'Q':
  232.             sw = 0;
  233.             (*eputs)(arg, out);
  234.             (*eputc)(' ', out);
  235.             break;
  236.         case 'r':
  237.             sw = 0;
  238.             in = fopen(arg, "r");
  239.             if ( in == NULL ) exit(exit_FAILED);
  240.             interact = 1;
  241.             break;
  242.         case 'R':
  243.             sw = 0;
  244.             in = fopen(arg, "r");
  245.             if ( in == NULL ) exit(exit_FAILED);
  246.             {    int count;
  247.                 while ( (count = fread(line, 1, 1, in)) > 0 )
  248.                   (*eputc)(line[0], out);
  249.             }
  250.             fclose(in);
  251.             break;
  252.         case 'u':
  253.           {    const char *up;
  254.             for ( up = arg; *up; up++ )
  255.               (*eputc)(toupper(*up), out);
  256.           }    sw = 0;
  257.             break;
  258.         case 'x':
  259. xx:        {    char *xp;
  260.             unsigned int xchr = 1;
  261.             for ( xp = arg; *xp; xp++ )
  262.             {    char ch = *xp;
  263.                 if ( !isxdigit(ch) ) return 1;
  264.                 xchr <<= 4;
  265.                 xchr += (isdigit(ch) ? ch - '0' :
  266.                      (isupper(ch) ? tolower(ch) : ch)
  267.                       - 'a' + 10);
  268.                 if ( xchr >= 0x100 )
  269.                 {    (*eputc)(xchr & 0xff, out);
  270.                     xchr = 1;
  271.                 }
  272.             }
  273.         }    sw = 0;
  274.             break;
  275.         }
  276.     }
  277.     if ( newline ) (*eputc)('\n', out);
  278.     if ( out != stdout ) fclose(out);
  279.     return exit_OK;
  280. }
  281.  
  282. static int
  283. hputc(int ch, FILE *out)
  284. {    static char *hex = "0123456789abcdef";
  285.     putc(hex[ch >> 4], out);
  286.     putc(hex[ch & 0xf], out);
  287.     return 0;
  288. }
  289.  
  290. static int
  291. hputs(char *str, FILE *out)
  292. {    while ( *str ) hputc(*str++ & 0xff, out);
  293.     return 0;
  294. }
  295.